home *** CD-ROM | disk | FTP | other *** search
/ F1 Licenseware / F1 Licenseware - Volume 1.iso / disks / 003.dms / 003.adf / TEXT / chapter17.txt < prev    next >
Text File  |  1992-09-02  |  8KB  |  268 lines
  1.  
  2.               The Absolute Beginners Guide To Amos
  3.               -------------------------------------
  4.                          Chapter seventeen
  5.                          ------------------
  6.  
  7.            The Answers to The Self Testing Quiz part 4:
  8.  
  9.                         1. B     6. A
  10.                         2. A     7. B
  11.                         3. A     8. C
  12.                         4. C     9. B
  13.                         5. C    10. C
  14.  
  15. ===========================================================================
  16.  
  17. Now I would like to cover DIMensioned Arrays I know it sounds frightening at
  18. first, I can remember trying to get to grips with it myself, but don`t
  19. be misled by the name of this command as it`s not as bad as it sounds.  
  20. It`s the concept that some people can find hard to grasp rather than the 
  21. usage.
  22.  
  23. THE CONCEPT OF ARRAYS:
  24. ----------------------
  25. Arrays are for manipulating large amounts of data or variables.  For example
  26. a league of 22 football teams could be grouped into an array called team$
  27. we would access a team like this:
  28.  
  29. TEAM$(0)
  30.  
  31. Where if the table was sorted might be Aston Villa for example.  
  32. Similarly this can also apply to numerical variables we could group together
  33. all of the money we spent in the last year on beer and fags in an array
  34. called BEER we could then:
  35.  
  36. PRINT beer(5) 
  37.  
  38. This would produce the figure we entered for week five.
  39.  
  40. Notice the only difference (so far) with a string array and a numerical array
  41. is the $ sign.
  42.  
  43. SETTING UP AN ARRAY
  44. -------------------
  45.  
  46. OK so we have 22 teams from the English Premier League and we want to group
  47. these into an array called team$.  First of all we must reserve some variable 
  48. space for our array using the DIM command.
  49.  
  50. DIM TEAM$ (21)
  51.  
  52. DIM tells Amos we want to reserve space for an array called team$ which will
  53. contain 22 items.  Arrays always start at zero, so for 22 teams we would 
  54. count from 0 to 21.
  55. Amos knows it`s a string array as we used a $ after the variable team.
  56. If we had put DIM team (21) Amos would presume we wanted a numerical array.
  57.  
  58.  
  59. Now then, how do we input the data? This is how:
  60.  
  61.  
  62. DATA "SPURS","ASTON VILLA","CHELSEA","NORWICH"
  63. DATA "NEWCASTLE","SWINDON","SHEFF WED","Q.P.R"
  64.  
  65. etc. until we have typed our 22 teams in.  Notice the exact format,
  66.  
  67. DATA String in quotes, comma, String in quotes, comma etc.
  68.  
  69. If we were handling our beer and fags numerical array we would enter the 
  70. numbers like this,
  71.  
  72. DATA 12,17,13,11,12
  73. DATA 22,54,11,0,9,7
  74. etc.
  75.  
  76. Almost the same except no quotes.
  77.  
  78.  
  79. Right then we have DIMensioned a 22 slot array for our team names and 
  80. typed the names into DATA statements, but Amos still does not know
  81. what to do with all this stuff.  At the moment Amos will DIMension your array
  82. and ignore the DATA.  We have to READ the DATA into the ARRAY.
  83.  
  84. FOR A=0 to 21      
  85.  
  86. READ TEAM$(A)
  87.  
  88. NEXT A
  89.  
  90. We must set up a FOR NEXT loop to read each team from the DATA list into the 
  91. array.  Because we used TEAM$ in the READ line Amos knows we wanted to READ 
  92. the DATA in our DIMmed array called TEAM$.
  93.  
  94.  
  95. The beer and fags numerical array would be almost identical.
  96.  
  97. FOR A=0 to 364
  98.  
  99. READ beer(A)
  100.  
  101. NEXT A  
  102.  
  103.  
  104.  
  105.  
  106. Note: Often it is a good idea to put a RESTORE command before you 
  107.       READ the DATA in.  This sets the internal DATA pointer to the 
  108.       beginning of the list.  If you get an OUT OF DATA error then
  109.       RESTORE could solve problem. An example would be:
  110.  
  111.       RESTORE league
  112.  
  113.       league:
  114.       DATA "SPURS","CHELSEA" etc.
  115.  
  116.       The league: bit is just a label so we can tell Amos what DATA we want
  117.       to RESTORE because some programs will contain more than one set of 
  118.       DATA statements.
  119.  
  120.  
  121.  
  122. So that is the painful part over the rest is plain sailing.  
  123. The DATA is now safely in the array and you could access it like this:
  124.  
  125. PRINT TEAM$(1)  
  126.  
  127. SPURS             <<< (This is what would be PRINTed on screen)
  128.  
  129.  
  130. PRINT TEAM$(2)
  131.  
  132. ASTON VILLA
  133.  
  134.  
  135. PRINT TEAM$ (3)
  136.  
  137. CHELSEA
  138.  
  139.  
  140. And the beer array,
  141.  
  142. PRINT beer(1)
  143.  
  144. 12
  145.  
  146.  
  147. PRINT beer(2)
  148.  
  149. 17
  150.  
  151.  
  152. PRINT beer (3)
  153.  
  154. 13
  155.  
  156.  
  157. But if we wanted to print all 22 teams on the screen a neater way would be
  158. to use a FOR NEXT loop similar to the one we used to READ the DATA in.
  159.  
  160. FOR A=0 TO 21
  161. PRINT TEAM$(A)
  162. NEXT A
  163.  
  164. Would print all 22 team names on the screen in a flash.  To do this to the 
  165. beer array we could just substitute the 21 for 364 and TEAM$ for beer.
  166.  
  167. One of the many bonuses of using of arrays is that we can use the Amos SORT
  168. command, which is fast and saves a lot of coding. 
  169.  
  170. If we want to SORT our array all we do is this:
  171.   
  172. SORT TEAM$ (0)
  173.  
  174. The zero is the start of our array.  For the beer array it`s,
  175.  
  176. SORT beer (0)
  177.  
  178.  
  179. And the team will all be sorted in alphabetical order and the beer numbers
  180. will be sorted in ascending order.
  181.  
  182.  
  183. There is a hell of a lot more to do with arrays than this little tutorial
  184. could possibly cover and I don`t want to go any further at this stage.
  185.  
  186. OK before we continue on to a new subject you may want to take a look at
  187. EXAMPLE17.Amos which uses our team$ idea.  The example program also covers
  188. the next part of this chapter which is all to do with PROCEDURES.  While
  189. DIM, DATA and such like are still fresh in your mind take a browse at it.
  190.  
  191.  
  192.  
  193. PROCEDURES
  194. ----------
  195.  
  196. Think of procedures as self contained programs a bit like subroutines.
  197. You can write a small part of your program and fold it out of sight into one
  198. line making your listings easier to read and easier to debug and program.
  199. Procedures are well worth taking the time to learn how to use and once you 
  200. get in the habit of using procedures you will always use them.
  201.  
  202. Here is a part of a program that we would probably want to use many times
  203. during the course of the program:
  204.  
  205. WHILE MOUSE KEY=0: WEND
  206.  
  207. Let`s presume there are five places in the program we need to use a mouse 
  208. wait (which is what this line does, remember?) We could have five separate 
  209. lines in the program we could use GOSUB or better we could put it in a
  210. PROCEDURE, this is how it`s done.
  211.  
  212.  
  213. PROCEDURE _mousewait
  214.  
  215. WHILE MOUSEKEY=0: WEND
  216.  
  217. END PROC
  218.  
  219. And that`s it, obviously the bigger the program we put in the procedure the
  220. more effective it becomes.  We can now call our procedure with:
  221.  
  222. _mousewait
  223.  
  224. And the procedure will be executed and return to the next command after the
  225. line we originally called the procedure from.  I could of called the 
  226. procedure anything I wanted but being descriptive helps later when your
  227. programs grow in size.
  228.  
  229. There are quite a few related commands to procedures I will as usual just
  230. cover the ones we really need to know about, so here goes.
  231.  
  232. POP PROC
  233. ---------
  234.  
  235. If you need to return from a procedure early for some reason this is your 
  236. man, an example could be:
  237.  
  238. IF A>5 then POP PROC
  239.  
  240. In other words if the A was more than five then end the procedure.  Don`t
  241. forget though that you still have to put END PROC at the END of your 
  242. PROCedure even if you do use POP PROC
  243.  
  244. The only other procedure related command we need to know about at the moment
  245. is:
  246.  
  247. GLOBAL
  248. ------
  249. When you put a program inside a procedure the procedure itself is a self
  250. contained module and any variables used inside that procedure will not
  251. effect any variables outside it even if they have the same name, unless that
  252. is, we assign them to be GLOBAL variables which means Amos will treat the 
  253. following variables the same inside and out of procedures, an example.
  254.  
  255. GLOBAL a$,team$(),beer(),f
  256.  
  257. This line makes a string called A$ an array called team$ an array called 
  258. beer and a lone variable called f all GLOBAL.  Notice that to make an array
  259. GLOBAL you must put () after it or GLOBAL will treat it as a normal variable.
  260.  
  261. OK that covers it on a need to know basis.  Now reload EXAMPLE17.Amos and you
  262. should understand the whole program a lot better.
  263.  
  264. End of chapter seventeen.
  265.  
  266.  
  267.   
  268.